//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS IoTThingsGraph service.
///
/// AWS IoT Things Graph AWS IoT Things Graph provides an integrated set of tools that enable developers to connect devices and services that use different standards,  such as units of measure and communication protocols. AWS IoT Things Graph makes it possible to build IoT applications with little to no code by connecting devices and services  and defining how they interact at an abstract level. For more information about how AWS IoT Things Graph works, see the User Guide. The AWS IoT Things Graph service is discontinued.
public struct IoTThingsGraph: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the IoTThingsGraph client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            amzTarget: "IotThingsGraphFrontEndService",
            serviceName: "IoTThingsGraph",
            serviceIdentifier: "iotthingsgraph",
            serviceProtocol: .json(version: "1.1"),
            apiVersion: "2018-09-06",
            endpoint: endpoint,
            errorType: IoTThingsGraphErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }





    // MARK: API Calls

    /// Associates a device with a concrete thing that is in the user's registry. A thing can be associated with only one device at a time. If you associate a thing with a new device id, its previous association will be removed.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func associateEntityToThing(_ input: AssociateEntityToThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AssociateEntityToThingResponse {
        try await self.client.execute(
            operation: "AssociateEntityToThing", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates a device with a concrete thing that is in the user's registry. A thing can be associated with only one device at a time. If you associate a thing with a new device id, its previous association will be removed.
    ///
    /// Parameters:
    ///   - entityId: The ID of the device to be associated with the thing. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:device:DEVICENAME
    ///   - namespaceVersion: The version of the user's namespace. Defaults to the latest version of the user's namespace.
    ///   - thingName: The name of the thing to which the entity is to be associated.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func associateEntityToThing(
        entityId: String,
        namespaceVersion: Int64? = nil,
        thingName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AssociateEntityToThingResponse {
        let input = AssociateEntityToThingRequest(
            entityId: entityId, 
            namespaceVersion: namespaceVersion, 
            thingName: thingName
        )
        return try await self.associateEntityToThing(input, logger: logger)
    }

    /// Creates a workflow template. Workflows can be created only in the user's namespace. (The public namespace contains only  entities.) The workflow can contain only entities in the specified namespace. The workflow is validated against the entities in the  latest version of the user's namespace unless another namespace version is specified in the request.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func createFlowTemplate(_ input: CreateFlowTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateFlowTemplateResponse {
        try await self.client.execute(
            operation: "CreateFlowTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a workflow template. Workflows can be created only in the user's namespace. (The public namespace contains only  entities.) The workflow can contain only entities in the specified namespace. The workflow is validated against the entities in the  latest version of the user's namespace unless another namespace version is specified in the request.
    ///
    /// Parameters:
    ///   - compatibleNamespaceVersion: The namespace version in which the workflow is to be created. If no value is specified, the latest version is used by default.
    ///   - definition: The workflow DefinitionDocument.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func createFlowTemplate(
        compatibleNamespaceVersion: Int64? = nil,
        definition: DefinitionDocument,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFlowTemplateResponse {
        let input = CreateFlowTemplateRequest(
            compatibleNamespaceVersion: compatibleNamespaceVersion, 
            definition: definition
        )
        return try await self.createFlowTemplate(input, logger: logger)
    }

    /// Creates a system instance.  This action validates the system instance, prepares the deployment-related resources. For Greengrass deployments, it updates the Greengrass group that is  specified by the greengrassGroupName parameter. It also adds a file to the S3 bucket specified by the s3BucketName parameter. You need to  call DeploySystemInstance after running this action. For Greengrass deployments, since this action modifies and adds resources to a Greengrass group and an S3 bucket on the caller's behalf, the calling identity must have write permissions  to both the specified Greengrass group and S3 bucket. Otherwise, the call will fail with an authorization error. For cloud deployments, this action requires a flowActionsRoleArn value. This is an IAM role  that has permissions to access AWS services, such as AWS Lambda and AWS IoT, that the flow uses when it executes. If the definition document doesn't specify a version of the user's namespace, the latest version will be used by default.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func createSystemInstance(_ input: CreateSystemInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSystemInstanceResponse {
        try await self.client.execute(
            operation: "CreateSystemInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a system instance.  This action validates the system instance, prepares the deployment-related resources. For Greengrass deployments, it updates the Greengrass group that is  specified by the greengrassGroupName parameter. It also adds a file to the S3 bucket specified by the s3BucketName parameter. You need to  call DeploySystemInstance after running this action. For Greengrass deployments, since this action modifies and adds resources to a Greengrass group and an S3 bucket on the caller's behalf, the calling identity must have write permissions  to both the specified Greengrass group and S3 bucket. Otherwise, the call will fail with an authorization error. For cloud deployments, this action requires a flowActionsRoleArn value. This is an IAM role  that has permissions to access AWS services, such as AWS Lambda and AWS IoT, that the flow uses when it executes. If the definition document doesn't specify a version of the user's namespace, the latest version will be used by default.
    ///
    /// Parameters:
    ///   - definition: 
    ///   - flowActionsRoleArn: The ARN of the IAM role that AWS IoT Things Graph will assume when it executes the flow. This role must have  read and write access to AWS Lambda and AWS IoT and any other AWS services that the flow uses when it executes.  This  value is required if the value of the target parameter is CLOUD.
    ///   - greengrassGroupName: The name of the Greengrass group where the system instance will be deployed. This value is required if  the value of the target parameter is GREENGRASS.
    ///   - metricsConfiguration: 
    ///   - s3BucketName: The name of the Amazon Simple Storage Service bucket that will be used to store and deploy the system instance's resource file. This value is required if  the value of the target parameter is GREENGRASS.
    ///   - tags: Metadata, consisting of key-value pairs, that can be used to categorize your system instances.
    ///   - target: The target type of the deployment. Valid values are GREENGRASS and CLOUD.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func createSystemInstance(
        definition: DefinitionDocument,
        flowActionsRoleArn: String? = nil,
        greengrassGroupName: String? = nil,
        metricsConfiguration: MetricsConfiguration? = nil,
        s3BucketName: String? = nil,
        tags: [Tag]? = nil,
        target: DeploymentTarget,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSystemInstanceResponse {
        let input = CreateSystemInstanceRequest(
            definition: definition, 
            flowActionsRoleArn: flowActionsRoleArn, 
            greengrassGroupName: greengrassGroupName, 
            metricsConfiguration: metricsConfiguration, 
            s3BucketName: s3BucketName, 
            tags: tags, 
            target: target
        )
        return try await self.createSystemInstance(input, logger: logger)
    }

    /// Creates a system. The system is validated against the entities in the  latest version of the user's namespace unless another namespace version is specified in the request.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func createSystemTemplate(_ input: CreateSystemTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSystemTemplateResponse {
        try await self.client.execute(
            operation: "CreateSystemTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a system. The system is validated against the entities in the  latest version of the user's namespace unless another namespace version is specified in the request.
    ///
    /// Parameters:
    ///   - compatibleNamespaceVersion: The namespace version in which the system is to be created. If no value is specified, the latest version is used by default.
    ///   - definition: The DefinitionDocument used to create the system.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func createSystemTemplate(
        compatibleNamespaceVersion: Int64? = nil,
        definition: DefinitionDocument,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSystemTemplateResponse {
        let input = CreateSystemTemplateRequest(
            compatibleNamespaceVersion: compatibleNamespaceVersion, 
            definition: definition
        )
        return try await self.createSystemTemplate(input, logger: logger)
    }

    /// Deletes a workflow. Any new system or deployment that contains this workflow will fail to update or deploy.  Existing deployments that contain the workflow will continue to run (since they use a snapshot of the workflow taken at the time of deployment).
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func deleteFlowTemplate(_ input: DeleteFlowTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteFlowTemplateResponse {
        try await self.client.execute(
            operation: "DeleteFlowTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a workflow. Any new system or deployment that contains this workflow will fail to update or deploy.  Existing deployments that contain the workflow will continue to run (since they use a snapshot of the workflow taken at the time of deployment).
    ///
    /// Parameters:
    ///   - id: The ID of the workflow to be deleted. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:workflow:WORKFLOWNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func deleteFlowTemplate(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFlowTemplateResponse {
        let input = DeleteFlowTemplateRequest(
            id: id
        )
        return try await self.deleteFlowTemplate(input, logger: logger)
    }

    /// Deletes the specified namespace. This action deletes all of the entities in the namespace. Delete the systems and flows that use entities in the namespace before performing this action. This action takes no  request parameters.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func deleteNamespace(_ input: DeleteNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteNamespaceResponse {
        try await self.client.execute(
            operation: "DeleteNamespace", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the specified namespace. This action deletes all of the entities in the namespace. Delete the systems and flows that use entities in the namespace before performing this action. This action takes no  request parameters.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func deleteNamespace(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteNamespaceResponse {
        let input = DeleteNamespaceRequest(
        )
        return try await self.deleteNamespace(input, logger: logger)
    }

    /// Deletes a system instance.  Only system instances that have never been deployed, or that have been undeployed can be deleted. Users can create a new system instance that has the same ID as a deleted system instance.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func deleteSystemInstance(_ input: DeleteSystemInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSystemInstanceResponse {
        try await self.client.execute(
            operation: "DeleteSystemInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a system instance.  Only system instances that have never been deployed, or that have been undeployed can be deleted. Users can create a new system instance that has the same ID as a deleted system instance.
    ///
    /// Parameters:
    ///   - id: The ID of the system instance to be deleted.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func deleteSystemInstance(
        id: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSystemInstanceResponse {
        let input = DeleteSystemInstanceRequest(
            id: id
        )
        return try await self.deleteSystemInstance(input, logger: logger)
    }

    /// Deletes a system. New deployments can't contain the system after its deletion.  Existing deployments that contain the system will continue to work because they use a snapshot of the system that is taken when it is deployed.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func deleteSystemTemplate(_ input: DeleteSystemTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteSystemTemplateResponse {
        try await self.client.execute(
            operation: "DeleteSystemTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a system. New deployments can't contain the system after its deletion.  Existing deployments that contain the system will continue to work because they use a snapshot of the system that is taken when it is deployed.
    ///
    /// Parameters:
    ///   - id: The ID of the system to be deleted. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:system:SYSTEMNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func deleteSystemTemplate(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteSystemTemplateResponse {
        let input = DeleteSystemTemplateRequest(
            id: id
        )
        return try await self.deleteSystemTemplate(input, logger: logger)
    }

    ///  Greengrass and Cloud Deployments  Deploys the system instance to the target specified in CreateSystemInstance.   Greengrass Deployments  If the system or any workflows and entities have been updated before this action is called, then the deployment will create a new Amazon Simple Storage Service  resource file and then deploy it. Since this action creates a Greengrass deployment on the caller's behalf, the calling identity must have write permissions  to the specified Greengrass group. Otherwise, the call will fail with an authorization error. For information about the artifacts that get added to your Greengrass core device when you use this API, see AWS IoT Things Graph and AWS IoT Greengrass.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func deploySystemInstance(_ input: DeploySystemInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeploySystemInstanceResponse {
        try await self.client.execute(
            operation: "DeploySystemInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    ///  Greengrass and Cloud Deployments  Deploys the system instance to the target specified in CreateSystemInstance.   Greengrass Deployments  If the system or any workflows and entities have been updated before this action is called, then the deployment will create a new Amazon Simple Storage Service  resource file and then deploy it. Since this action creates a Greengrass deployment on the caller's behalf, the calling identity must have write permissions  to the specified Greengrass group. Otherwise, the call will fail with an authorization error. For information about the artifacts that get added to your Greengrass core device when you use this API, see AWS IoT Things Graph and AWS IoT Greengrass.
    ///
    /// Parameters:
    ///   - id: The ID of the system instance. This value is returned by the CreateSystemInstance action. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:deployment:DEPLOYMENTNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func deploySystemInstance(
        id: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeploySystemInstanceResponse {
        let input = DeploySystemInstanceRequest(
            id: id
        )
        return try await self.deploySystemInstance(input, logger: logger)
    }

    /// Deprecates the specified workflow. This action marks the workflow for deletion. Deprecated flows can't be deployed, but existing deployments will continue to run.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func deprecateFlowTemplate(_ input: DeprecateFlowTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeprecateFlowTemplateResponse {
        try await self.client.execute(
            operation: "DeprecateFlowTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deprecates the specified workflow. This action marks the workflow for deletion. Deprecated flows can't be deployed, but existing deployments will continue to run.
    ///
    /// Parameters:
    ///   - id: The ID of the workflow to be deleted. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:workflow:WORKFLOWNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func deprecateFlowTemplate(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeprecateFlowTemplateResponse {
        let input = DeprecateFlowTemplateRequest(
            id: id
        )
        return try await self.deprecateFlowTemplate(input, logger: logger)
    }

    /// Deprecates the specified system.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func deprecateSystemTemplate(_ input: DeprecateSystemTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeprecateSystemTemplateResponse {
        try await self.client.execute(
            operation: "DeprecateSystemTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deprecates the specified system.
    ///
    /// Parameters:
    ///   - id: The ID of the system to delete. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:system:SYSTEMNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func deprecateSystemTemplate(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeprecateSystemTemplateResponse {
        let input = DeprecateSystemTemplateRequest(
            id: id
        )
        return try await self.deprecateSystemTemplate(input, logger: logger)
    }

    /// Gets the latest version of the user's namespace and the public version that it is tracking.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func describeNamespace(_ input: DescribeNamespaceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeNamespaceResponse {
        try await self.client.execute(
            operation: "DescribeNamespace", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the latest version of the user's namespace and the public version that it is tracking.
    ///
    /// Parameters:
    ///   - namespaceName: The name of the user's namespace. Set this to aws to get the public namespace.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func describeNamespace(
        namespaceName: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeNamespaceResponse {
        let input = DescribeNamespaceRequest(
            namespaceName: namespaceName
        )
        return try await self.describeNamespace(input, logger: logger)
    }

    /// Dissociates a device entity from a concrete thing. The action takes only the type of the entity that you need to dissociate because only  one entity of a particular type can be associated with a thing.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func dissociateEntityFromThing(_ input: DissociateEntityFromThingRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DissociateEntityFromThingResponse {
        try await self.client.execute(
            operation: "DissociateEntityFromThing", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Dissociates a device entity from a concrete thing. The action takes only the type of the entity that you need to dissociate because only  one entity of a particular type can be associated with a thing.
    ///
    /// Parameters:
    ///   - entityType: The entity type from which to disassociate the thing.
    ///   - thingName: The name of the thing to disassociate.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func dissociateEntityFromThing(
        entityType: EntityType,
        thingName: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DissociateEntityFromThingResponse {
        let input = DissociateEntityFromThingRequest(
            entityType: entityType, 
            thingName: thingName
        )
        return try await self.dissociateEntityFromThing(input, logger: logger)
    }

    /// Gets definitions of the specified entities. Uses the latest version of the user's namespace by default. This API returns the  following TDM entities.   Properties   States   Events   Actions   Capabilities   Mappings   Devices   Device Models   Services   This action doesn't return definitions for systems, flows, and deployments.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getEntities(_ input: GetEntitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetEntitiesResponse {
        try await self.client.execute(
            operation: "GetEntities", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets definitions of the specified entities. Uses the latest version of the user's namespace by default. This API returns the  following TDM entities.   Properties   States   Events   Actions   Capabilities   Mappings   Devices   Device Models   Services   This action doesn't return definitions for systems, flows, and deployments.
    ///
    /// Parameters:
    ///   - ids: An array of entity IDs. The IDs should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:device:DEVICENAME
    ///   - namespaceVersion: The version of the user's namespace. Defaults to the latest version of the user's namespace.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getEntities(
        ids: [String],
        namespaceVersion: Int64? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetEntitiesResponse {
        let input = GetEntitiesRequest(
            ids: ids, 
            namespaceVersion: namespaceVersion
        )
        return try await self.getEntities(input, logger: logger)
    }

    /// Gets the latest version of the DefinitionDocument and FlowTemplateSummary for the specified workflow.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getFlowTemplate(_ input: GetFlowTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFlowTemplateResponse {
        try await self.client.execute(
            operation: "GetFlowTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the latest version of the DefinitionDocument and FlowTemplateSummary for the specified workflow.
    ///
    /// Parameters:
    ///   - id: The ID of the workflow. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:workflow:WORKFLOWNAME
    ///   - revisionNumber: The number of the workflow revision to retrieve.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getFlowTemplate(
        id: String,
        revisionNumber: Int64? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFlowTemplateResponse {
        let input = GetFlowTemplateRequest(
            id: id, 
            revisionNumber: revisionNumber
        )
        return try await self.getFlowTemplate(input, logger: logger)
    }

    /// Gets revisions of the specified workflow. Only the last 100 revisions are stored. If the workflow has been deprecated,  this action will return revisions that occurred before the deprecation. This action won't work for workflows that have been deleted.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getFlowTemplateRevisions(_ input: GetFlowTemplateRevisionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFlowTemplateRevisionsResponse {
        try await self.client.execute(
            operation: "GetFlowTemplateRevisions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets revisions of the specified workflow. Only the last 100 revisions are stored. If the workflow has been deprecated,  this action will return revisions that occurred before the deprecation. This action won't work for workflows that have been deleted.
    ///
    /// Parameters:
    ///   - id: The ID of the workflow. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:workflow:WORKFLOWNAME
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getFlowTemplateRevisions(
        id: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFlowTemplateRevisionsResponse {
        let input = GetFlowTemplateRevisionsRequest(
            id: id, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getFlowTemplateRevisions(input, logger: logger)
    }

    /// Gets the status of a namespace deletion task.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getNamespaceDeletionStatus(_ input: GetNamespaceDeletionStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetNamespaceDeletionStatusResponse {
        try await self.client.execute(
            operation: "GetNamespaceDeletionStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the status of a namespace deletion task.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getNamespaceDeletionStatus(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetNamespaceDeletionStatusResponse {
        let input = GetNamespaceDeletionStatusRequest(
        )
        return try await self.getNamespaceDeletionStatus(input, logger: logger)
    }

    /// Gets a system instance.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getSystemInstance(_ input: GetSystemInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSystemInstanceResponse {
        try await self.client.execute(
            operation: "GetSystemInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a system instance.
    ///
    /// Parameters:
    ///   - id: The ID of the system deployment instance. This value is returned by CreateSystemInstance. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:deployment:DEPLOYMENTNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getSystemInstance(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSystemInstanceResponse {
        let input = GetSystemInstanceRequest(
            id: id
        )
        return try await self.getSystemInstance(input, logger: logger)
    }

    /// Gets a system.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getSystemTemplate(_ input: GetSystemTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSystemTemplateResponse {
        try await self.client.execute(
            operation: "GetSystemTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets a system.
    ///
    /// Parameters:
    ///   - id: The ID of the system to get. This ID must be in the user's namespace. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:system:SYSTEMNAME
    ///   - revisionNumber: The number that specifies the revision of the system to get.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getSystemTemplate(
        id: String,
        revisionNumber: Int64? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSystemTemplateResponse {
        let input = GetSystemTemplateRequest(
            id: id, 
            revisionNumber: revisionNumber
        )
        return try await self.getSystemTemplate(input, logger: logger)
    }

    /// Gets revisions made to the specified system template. Only the previous 100 revisions are stored. If the system has been deprecated, this action will return  the revisions that occurred before its deprecation. This action won't work with systems that have been deleted.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getSystemTemplateRevisions(_ input: GetSystemTemplateRevisionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSystemTemplateRevisionsResponse {
        try await self.client.execute(
            operation: "GetSystemTemplateRevisions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets revisions made to the specified system template. Only the previous 100 revisions are stored. If the system has been deprecated, this action will return  the revisions that occurred before its deprecation. This action won't work with systems that have been deleted.
    ///
    /// Parameters:
    ///   - id: The ID of the system template. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:system:SYSTEMNAME
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getSystemTemplateRevisions(
        id: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSystemTemplateRevisionsResponse {
        let input = GetSystemTemplateRevisionsRequest(
            id: id, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.getSystemTemplateRevisions(input, logger: logger)
    }

    /// Gets the status of the specified upload.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func getUploadStatus(_ input: GetUploadStatusRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUploadStatusResponse {
        try await self.client.execute(
            operation: "GetUploadStatus", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Gets the status of the specified upload.
    ///
    /// Parameters:
    ///   - uploadId: The ID of the upload. This value is returned by the UploadEntityDefinitions action.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getUploadStatus(
        uploadId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUploadStatusResponse {
        let input = GetUploadStatusRequest(
            uploadId: uploadId
        )
        return try await self.getUploadStatus(input, logger: logger)
    }

    /// Returns a list of objects that contain information about events in a flow execution.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func listFlowExecutionMessages(_ input: ListFlowExecutionMessagesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFlowExecutionMessagesResponse {
        try await self.client.execute(
            operation: "ListFlowExecutionMessages", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Returns a list of objects that contain information about events in a flow execution.
    ///
    /// Parameters:
    ///   - flowExecutionId: The ID of the flow execution.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func listFlowExecutionMessages(
        flowExecutionId: String,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFlowExecutionMessagesResponse {
        let input = ListFlowExecutionMessagesRequest(
            flowExecutionId: flowExecutionId, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFlowExecutionMessages(input, logger: logger)
    }

    /// Lists all tags on an AWS IoT Things Graph resource.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Lists all tags on an AWS IoT Things Graph resource.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of tags to return.
    ///   - nextToken: The token that specifies the next page of results to return.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource whose tags are to be returned.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func listTagsForResource(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Searches for entities of the specified type. You can search for entities in your namespace and the public namespace that you're tracking.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func searchEntities(_ input: SearchEntitiesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchEntitiesResponse {
        try await self.client.execute(
            operation: "SearchEntities", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for entities of the specified type. You can search for entities in your namespace and the public namespace that you're tracking.
    ///
    /// Parameters:
    ///   - entityTypes: The entity types for which to search.
    ///   - filters: Optional filter to apply to the search. Valid filters are NAME NAMESPACE, SEMANTIC_TYPE_PATH and REFERENCED_ENTITY_ID.  REFERENCED_ENTITY_ID filters on entities that are used by the entity in the result set. For example,  you can filter on the ID of a property that is used in a state. Multiple filters function as OR criteria in the query. Multiple values passed inside the filter function as AND criteria.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - namespaceVersion: The version of the user's namespace. Defaults to the latest version of the user's namespace.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchEntities(
        entityTypes: [EntityType],
        filters: [EntityFilter]? = nil,
        maxResults: Int? = nil,
        namespaceVersion: Int64? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchEntitiesResponse {
        let input = SearchEntitiesRequest(
            entityTypes: entityTypes, 
            filters: filters, 
            maxResults: maxResults, 
            namespaceVersion: namespaceVersion, 
            nextToken: nextToken
        )
        return try await self.searchEntities(input, logger: logger)
    }

    /// Searches for AWS IoT Things Graph workflow execution instances.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func searchFlowExecutions(_ input: SearchFlowExecutionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchFlowExecutionsResponse {
        try await self.client.execute(
            operation: "SearchFlowExecutions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for AWS IoT Things Graph workflow execution instances.
    ///
    /// Parameters:
    ///   - endTime: The date and time of the latest flow execution to return.
    ///   - flowExecutionId: The ID of a flow execution.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - startTime: The date and time of the earliest flow execution to return.
    ///   - systemInstanceId: The ID of the system instance that contains the flow.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchFlowExecutions(
        endTime: Date? = nil,
        flowExecutionId: String? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        startTime: Date? = nil,
        systemInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchFlowExecutionsResponse {
        let input = SearchFlowExecutionsRequest(
            endTime: endTime, 
            flowExecutionId: flowExecutionId, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            startTime: startTime, 
            systemInstanceId: systemInstanceId
        )
        return try await self.searchFlowExecutions(input, logger: logger)
    }

    /// Searches for summary information about workflows.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func searchFlowTemplates(_ input: SearchFlowTemplatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchFlowTemplatesResponse {
        try await self.client.execute(
            operation: "SearchFlowTemplates", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for summary information about workflows.
    ///
    /// Parameters:
    ///   - filters: An array of objects that limit the result set. The only valid filter is DEVICE_MODEL_ID.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchFlowTemplates(
        filters: [FlowTemplateFilter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchFlowTemplatesResponse {
        let input = SearchFlowTemplatesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchFlowTemplates(input, logger: logger)
    }

    /// Searches for system instances in the user's account.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func searchSystemInstances(_ input: SearchSystemInstancesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchSystemInstancesResponse {
        try await self.client.execute(
            operation: "SearchSystemInstances", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for system instances in the user's account.
    ///
    /// Parameters:
    ///   - filters: Optional filter to apply to the search. Valid filters are SYSTEM_TEMPLATE_ID, STATUS, and  GREENGRASS_GROUP_NAME. Multiple filters function as OR criteria in the query. Multiple values passed inside the filter function as AND criteria.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchSystemInstances(
        filters: [SystemInstanceFilter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchSystemInstancesResponse {
        let input = SearchSystemInstancesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchSystemInstances(input, logger: logger)
    }

    /// Searches for summary information about systems in the user's account. You can filter by the ID of a workflow to return only systems that use the specified workflow.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func searchSystemTemplates(_ input: SearchSystemTemplatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchSystemTemplatesResponse {
        try await self.client.execute(
            operation: "SearchSystemTemplates", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for summary information about systems in the user's account. You can filter by the ID of a workflow to return only systems that use the specified workflow.
    ///
    /// Parameters:
    ///   - filters: An array of filters that limit the result set. The only valid filter is FLOW_TEMPLATE_ID.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchSystemTemplates(
        filters: [SystemTemplateFilter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchSystemTemplatesResponse {
        let input = SearchSystemTemplatesRequest(
            filters: filters, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.searchSystemTemplates(input, logger: logger)
    }

    /// Searches for things associated with the specified entity. You can search by both device and device model. For example, if two different devices, camera1 and camera2, implement the camera device model, the user can associate thing1 to camera1 and thing2 to camera2. SearchThings(camera2) will return only thing2, but SearchThings(camera) will return both thing1 and thing2. This action searches for exact matches and doesn't perform partial text matching.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func searchThings(_ input: SearchThingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchThingsResponse {
        try await self.client.execute(
            operation: "SearchThings", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Searches for things associated with the specified entity. You can search by both device and device model. For example, if two different devices, camera1 and camera2, implement the camera device model, the user can associate thing1 to camera1 and thing2 to camera2. SearchThings(camera2) will return only thing2, but SearchThings(camera) will return both thing1 and thing2. This action searches for exact matches and doesn't perform partial text matching.
    ///
    /// Parameters:
    ///   - entityId: The ID of the entity to which the things are associated. The IDs should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:device:DEVICENAME
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - namespaceVersion: The version of the user's namespace. Defaults to the latest version of the user's namespace.
    ///   - nextToken: The string that specifies the next page of results. Use this when you're paginating results.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchThings(
        entityId: String,
        maxResults: Int? = nil,
        namespaceVersion: Int64? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchThingsResponse {
        let input = SearchThingsRequest(
            entityId: entityId, 
            maxResults: maxResults, 
            namespaceVersion: namespaceVersion, 
            nextToken: nextToken
        )
        return try await self.searchThings(input, logger: logger)
    }

    /// Creates a tag for the specified resource.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates a tag for the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource whose tags are returned.
    ///   - tags: A list of tags to add to the resource.>
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [Tag],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Removes a system instance from its target (Cloud or Greengrass).
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func undeploySystemInstance(_ input: UndeploySystemInstanceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UndeploySystemInstanceResponse {
        try await self.client.execute(
            operation: "UndeploySystemInstance", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a system instance from its target (Cloud or Greengrass).
    ///
    /// Parameters:
    ///   - id: The ID of the system instance to remove from its target.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func undeploySystemInstance(
        id: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UndeploySystemInstanceResponse {
        let input = UndeploySystemInstanceRequest(
            id: id
        )
        return try await self.undeploySystemInstance(input, logger: logger)
    }

    /// Removes a tag from the specified resource.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes a tag from the specified resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource whose tags are to be removed.
    ///   - tagKeys: A list of tag key names to remove from the resource. You don't specify the value. Both the key and its associated value are removed.  This parameter to the API requires a JSON text string argument. For information on how to format a JSON parameter for the various command line tool environments, see Using JSON for Parameters in the AWS CLI User Guide.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String],
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the specified workflow. All deployed systems and system instances that use the workflow will see the changes in the flow when it is redeployed. If you don't want this  behavior, copy the workflow (creating a new workflow with a different ID), and update the copy. The workflow can contain only entities in the specified namespace.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func updateFlowTemplate(_ input: UpdateFlowTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFlowTemplateResponse {
        try await self.client.execute(
            operation: "UpdateFlowTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified workflow. All deployed systems and system instances that use the workflow will see the changes in the flow when it is redeployed. If you don't want this  behavior, copy the workflow (creating a new workflow with a different ID), and update the copy. The workflow can contain only entities in the specified namespace.
    ///
    /// Parameters:
    ///   - compatibleNamespaceVersion: The version of the user's namespace. If no value is specified, the latest version is used by default. Use the GetFlowTemplateRevisions if you want to find earlier revisions of the flow  to update.
    ///   - definition: The DefinitionDocument that contains the updated workflow definition.
    ///   - id: The ID of the workflow to be updated. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:workflow:WORKFLOWNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func updateFlowTemplate(
        compatibleNamespaceVersion: Int64? = nil,
        definition: DefinitionDocument,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFlowTemplateResponse {
        let input = UpdateFlowTemplateRequest(
            compatibleNamespaceVersion: compatibleNamespaceVersion, 
            definition: definition, 
            id: id
        )
        return try await self.updateFlowTemplate(input, logger: logger)
    }

    /// Updates the specified system. You don't need to run this action after updating a workflow. Any deployment that uses the system will see the changes in the system when it is redeployed.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func updateSystemTemplate(_ input: UpdateSystemTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSystemTemplateResponse {
        try await self.client.execute(
            operation: "UpdateSystemTemplate", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the specified system. You don't need to run this action after updating a workflow. Any deployment that uses the system will see the changes in the system when it is redeployed.
    ///
    /// Parameters:
    ///   - compatibleNamespaceVersion: The version of the user's namespace. Defaults to the latest version of the user's namespace. If no value is specified, the latest version is used by default.
    ///   - definition: The DefinitionDocument that contains the updated system definition.
    ///   - id: The ID of the system to be updated. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:system:SYSTEMNAME
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func updateSystemTemplate(
        compatibleNamespaceVersion: Int64? = nil,
        definition: DefinitionDocument,
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSystemTemplateResponse {
        let input = UpdateSystemTemplateRequest(
            compatibleNamespaceVersion: compatibleNamespaceVersion, 
            definition: definition, 
            id: id
        )
        return try await self.updateSystemTemplate(input, logger: logger)
    }

    /// Asynchronously uploads one or more entity definitions to the user's namespace. The document parameter is required if  syncWithPublicNamespace and deleteExistingEntites are false. If the syncWithPublicNamespace parameter  is set to  true, the user's namespace will synchronize with the latest version of the public namespace. If deprecateExistingEntities is set to true,  all entities in the latest version will be deleted before the new DefinitionDocument is uploaded. When a user uploads entity definitions for the first time, the service creates a new namespace for the user. The new namespace tracks the public namespace. Currently users  can have only one namespace. The namespace version increments whenever a user uploads entity definitions that are backwards-incompatible and whenever a user sets the  syncWithPublicNamespace parameter or the deprecateExistingEntities parameter to true. The IDs for all of the entities should be in URN format. Each entity must be in the user's namespace. Users can't create entities in the public namespace, but entity definitions can refer to entities in the public namespace. Valid entities are Device, DeviceModel, Service, Capability, State, Action, Event, Property,  Mapping, Enum.
    @available(*, deprecated, message: "since: 2022-08-30")
    @Sendable
    @inlinable
    public func uploadEntityDefinitions(_ input: UploadEntityDefinitionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UploadEntityDefinitionsResponse {
        try await self.client.execute(
            operation: "UploadEntityDefinitions", 
            path: "/", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Asynchronously uploads one or more entity definitions to the user's namespace. The document parameter is required if  syncWithPublicNamespace and deleteExistingEntites are false. If the syncWithPublicNamespace parameter  is set to  true, the user's namespace will synchronize with the latest version of the public namespace. If deprecateExistingEntities is set to true,  all entities in the latest version will be deleted before the new DefinitionDocument is uploaded. When a user uploads entity definitions for the first time, the service creates a new namespace for the user. The new namespace tracks the public namespace. Currently users  can have only one namespace. The namespace version increments whenever a user uploads entity definitions that are backwards-incompatible and whenever a user sets the  syncWithPublicNamespace parameter or the deprecateExistingEntities parameter to true. The IDs for all of the entities should be in URN format. Each entity must be in the user's namespace. Users can't create entities in the public namespace, but entity definitions can refer to entities in the public namespace. Valid entities are Device, DeviceModel, Service, Capability, State, Action, Event, Property,  Mapping, Enum.
    ///
    /// Parameters:
    ///   - deprecateExistingEntities: A Boolean that specifies whether to deprecate all entities in the latest version before uploading the new DefinitionDocument.  If set to true, the upload will create a new namespace version.
    ///   - document: The DefinitionDocument that defines the updated entities.
    ///   - syncWithPublicNamespace: A Boolean that specifies whether to synchronize with the latest version of the public namespace. If set to true, the upload will create a new namespace version.
    ///   - logger: Logger use during operation
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func uploadEntityDefinitions(
        deprecateExistingEntities: Bool? = nil,
        document: DefinitionDocument? = nil,
        syncWithPublicNamespace: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UploadEntityDefinitionsResponse {
        let input = UploadEntityDefinitionsRequest(
            deprecateExistingEntities: deprecateExistingEntities, 
            document: document, 
            syncWithPublicNamespace: syncWithPublicNamespace
        )
        return try await self.uploadEntityDefinitions(input, logger: logger)
    }
}

extension IoTThingsGraph {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: IoTThingsGraph, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension IoTThingsGraph {
    /// Return PaginatorSequence for operation ``getFlowTemplateRevisions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getFlowTemplateRevisionsPaginator(
        _ input: GetFlowTemplateRevisionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetFlowTemplateRevisionsRequest, GetFlowTemplateRevisionsResponse> {
        return .init(
            input: input,
            command: self.getFlowTemplateRevisions,
            inputKey: \GetFlowTemplateRevisionsRequest.nextToken,
            outputKey: \GetFlowTemplateRevisionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getFlowTemplateRevisions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The ID of the workflow. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:workflow:WORKFLOWNAME
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getFlowTemplateRevisionsPaginator(
        id: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetFlowTemplateRevisionsRequest, GetFlowTemplateRevisionsResponse> {
        let input = GetFlowTemplateRevisionsRequest(
            id: id, 
            maxResults: maxResults
        )
        return self.getFlowTemplateRevisionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getSystemTemplateRevisions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getSystemTemplateRevisionsPaginator(
        _ input: GetSystemTemplateRevisionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetSystemTemplateRevisionsRequest, GetSystemTemplateRevisionsResponse> {
        return .init(
            input: input,
            command: self.getSystemTemplateRevisions,
            inputKey: \GetSystemTemplateRevisionsRequest.nextToken,
            outputKey: \GetSystemTemplateRevisionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getSystemTemplateRevisions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - id: The ID of the system template. The ID should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:system:SYSTEMNAME
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func getSystemTemplateRevisionsPaginator(
        id: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetSystemTemplateRevisionsRequest, GetSystemTemplateRevisionsResponse> {
        let input = GetSystemTemplateRevisionsRequest(
            id: id, 
            maxResults: maxResults
        )
        return self.getSystemTemplateRevisionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFlowExecutionMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func listFlowExecutionMessagesPaginator(
        _ input: ListFlowExecutionMessagesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFlowExecutionMessagesRequest, ListFlowExecutionMessagesResponse> {
        return .init(
            input: input,
            command: self.listFlowExecutionMessages,
            inputKey: \ListFlowExecutionMessagesRequest.nextToken,
            outputKey: \ListFlowExecutionMessagesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFlowExecutionMessages(_:logger:)``.
    ///
    /// - Parameters:
    ///   - flowExecutionId: The ID of the flow execution.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func listFlowExecutionMessagesPaginator(
        flowExecutionId: String,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFlowExecutionMessagesRequest, ListFlowExecutionMessagesResponse> {
        let input = ListFlowExecutionMessagesRequest(
            flowExecutionId: flowExecutionId, 
            maxResults: maxResults
        )
        return self.listFlowExecutionMessagesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listTagsForResource(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func listTagsForResourcePaginator(
        _ input: ListTagsForResourceRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListTagsForResourceRequest, ListTagsForResourceResponse> {
        return .init(
            input: input,
            command: self.listTagsForResource,
            inputKey: \ListTagsForResourceRequest.nextToken,
            outputKey: \ListTagsForResourceResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listTagsForResource(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of tags to return.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource whose tags are to be returned.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func listTagsForResourcePaginator(
        maxResults: Int? = nil,
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListTagsForResourceRequest, ListTagsForResourceResponse> {
        let input = ListTagsForResourceRequest(
            maxResults: maxResults, 
            resourceArn: resourceArn
        )
        return self.listTagsForResourcePaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchEntities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchEntitiesPaginator(
        _ input: SearchEntitiesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchEntitiesRequest, SearchEntitiesResponse> {
        return .init(
            input: input,
            command: self.searchEntities,
            inputKey: \SearchEntitiesRequest.nextToken,
            outputKey: \SearchEntitiesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchEntities(_:logger:)``.
    ///
    /// - Parameters:
    ///   - entityTypes: The entity types for which to search.
    ///   - filters: Optional filter to apply to the search. Valid filters are NAME NAMESPACE, SEMANTIC_TYPE_PATH and REFERENCED_ENTITY_ID.  REFERENCED_ENTITY_ID filters on entities that are used by the entity in the result set. For example,  you can filter on the ID of a property that is used in a state. Multiple filters function as OR criteria in the query. Multiple values passed inside the filter function as AND criteria.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - namespaceVersion: The version of the user's namespace. Defaults to the latest version of the user's namespace.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchEntitiesPaginator(
        entityTypes: [EntityType],
        filters: [EntityFilter]? = nil,
        maxResults: Int? = nil,
        namespaceVersion: Int64? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchEntitiesRequest, SearchEntitiesResponse> {
        let input = SearchEntitiesRequest(
            entityTypes: entityTypes, 
            filters: filters, 
            maxResults: maxResults, 
            namespaceVersion: namespaceVersion
        )
        return self.searchEntitiesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchFlowExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchFlowExecutionsPaginator(
        _ input: SearchFlowExecutionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchFlowExecutionsRequest, SearchFlowExecutionsResponse> {
        return .init(
            input: input,
            command: self.searchFlowExecutions,
            inputKey: \SearchFlowExecutionsRequest.nextToken,
            outputKey: \SearchFlowExecutionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchFlowExecutions(_:logger:)``.
    ///
    /// - Parameters:
    ///   - endTime: The date and time of the latest flow execution to return.
    ///   - flowExecutionId: The ID of a flow execution.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - startTime: The date and time of the earliest flow execution to return.
    ///   - systemInstanceId: The ID of the system instance that contains the flow.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchFlowExecutionsPaginator(
        endTime: Date? = nil,
        flowExecutionId: String? = nil,
        maxResults: Int? = nil,
        startTime: Date? = nil,
        systemInstanceId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchFlowExecutionsRequest, SearchFlowExecutionsResponse> {
        let input = SearchFlowExecutionsRequest(
            endTime: endTime, 
            flowExecutionId: flowExecutionId, 
            maxResults: maxResults, 
            startTime: startTime, 
            systemInstanceId: systemInstanceId
        )
        return self.searchFlowExecutionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchFlowTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchFlowTemplatesPaginator(
        _ input: SearchFlowTemplatesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchFlowTemplatesRequest, SearchFlowTemplatesResponse> {
        return .init(
            input: input,
            command: self.searchFlowTemplates,
            inputKey: \SearchFlowTemplatesRequest.nextToken,
            outputKey: \SearchFlowTemplatesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchFlowTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: An array of objects that limit the result set. The only valid filter is DEVICE_MODEL_ID.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchFlowTemplatesPaginator(
        filters: [FlowTemplateFilter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchFlowTemplatesRequest, SearchFlowTemplatesResponse> {
        let input = SearchFlowTemplatesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchFlowTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchSystemInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchSystemInstancesPaginator(
        _ input: SearchSystemInstancesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchSystemInstancesRequest, SearchSystemInstancesResponse> {
        return .init(
            input: input,
            command: self.searchSystemInstances,
            inputKey: \SearchSystemInstancesRequest.nextToken,
            outputKey: \SearchSystemInstancesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchSystemInstances(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: Optional filter to apply to the search. Valid filters are SYSTEM_TEMPLATE_ID, STATUS, and  GREENGRASS_GROUP_NAME. Multiple filters function as OR criteria in the query. Multiple values passed inside the filter function as AND criteria.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchSystemInstancesPaginator(
        filters: [SystemInstanceFilter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchSystemInstancesRequest, SearchSystemInstancesResponse> {
        let input = SearchSystemInstancesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchSystemInstancesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchSystemTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchSystemTemplatesPaginator(
        _ input: SearchSystemTemplatesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchSystemTemplatesRequest, SearchSystemTemplatesResponse> {
        return .init(
            input: input,
            command: self.searchSystemTemplates,
            inputKey: \SearchSystemTemplatesRequest.nextToken,
            outputKey: \SearchSystemTemplatesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchSystemTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filters: An array of filters that limit the result set. The only valid filter is FLOW_TEMPLATE_ID.
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchSystemTemplatesPaginator(
        filters: [SystemTemplateFilter]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchSystemTemplatesRequest, SearchSystemTemplatesResponse> {
        let input = SearchSystemTemplatesRequest(
            filters: filters, 
            maxResults: maxResults
        )
        return self.searchSystemTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchThings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchThingsPaginator(
        _ input: SearchThingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchThingsRequest, SearchThingsResponse> {
        return .init(
            input: input,
            command: self.searchThings,
            inputKey: \SearchThingsRequest.nextToken,
            outputKey: \SearchThingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchThings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - entityId: The ID of the entity to which the things are associated. The IDs should be in the following format.  urn:tdm:REGION/ACCOUNT ID/default:device:DEVICENAME
    ///   - maxResults: The maximum number of results to return in the response.
    ///   - namespaceVersion: The version of the user's namespace. Defaults to the latest version of the user's namespace.
    ///   - logger: Logger used for logging
    @available(*, deprecated, message: "since: 2022-08-30")
    @inlinable
    public func searchThingsPaginator(
        entityId: String,
        maxResults: Int? = nil,
        namespaceVersion: Int64? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchThingsRequest, SearchThingsResponse> {
        let input = SearchThingsRequest(
            entityId: entityId, 
            maxResults: maxResults, 
            namespaceVersion: namespaceVersion
        )
        return self.searchThingsPaginator(input, logger: logger)
    }
}

extension IoTThingsGraph.GetFlowTemplateRevisionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.GetFlowTemplateRevisionsRequest {
        return .init(
            id: self.id,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTThingsGraph.GetSystemTemplateRevisionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.GetSystemTemplateRevisionsRequest {
        return .init(
            id: self.id,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTThingsGraph.ListFlowExecutionMessagesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.ListFlowExecutionMessagesRequest {
        return .init(
            flowExecutionId: self.flowExecutionId,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTThingsGraph.ListTagsForResourceRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.ListTagsForResourceRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceArn: self.resourceArn
        )
    }
}

extension IoTThingsGraph.SearchEntitiesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.SearchEntitiesRequest {
        return .init(
            entityTypes: self.entityTypes,
            filters: self.filters,
            maxResults: self.maxResults,
            namespaceVersion: self.namespaceVersion,
            nextToken: token
        )
    }
}

extension IoTThingsGraph.SearchFlowExecutionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.SearchFlowExecutionsRequest {
        return .init(
            endTime: self.endTime,
            flowExecutionId: self.flowExecutionId,
            maxResults: self.maxResults,
            nextToken: token,
            startTime: self.startTime,
            systemInstanceId: self.systemInstanceId
        )
    }
}

extension IoTThingsGraph.SearchFlowTemplatesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.SearchFlowTemplatesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTThingsGraph.SearchSystemInstancesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.SearchSystemInstancesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTThingsGraph.SearchSystemTemplatesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.SearchSystemTemplatesRequest {
        return .init(
            filters: self.filters,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension IoTThingsGraph.SearchThingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> IoTThingsGraph.SearchThingsRequest {
        return .init(
            entityId: self.entityId,
            maxResults: self.maxResults,
            namespaceVersion: self.namespaceVersion,
            nextToken: token
        )
    }
}
